#Pruebas
from tablero import  Tablero
import paises as paises
from jugador import Jugador
from constantes import *
from mazo import Mazo
from mazo import Tarjeta
from interfaz import Interfaz
from teg import TEG
from dados import Dados


def ejecutar_prueba(resultado, prueba=""):
	"""Si el resultado (booleano) es True (resultado_esperado es igual al resultado_obtenido) se imprime
	un mensaje notificando que la prueba fue exitosa, en caso contrario se notifica que la
	prueba fallo."""
	if resultado:
		print "{0}: Prueba exitosa.".format(prueba)
	else:
		print "{0}: Prueba fallida.".format(prueba)


def obtener_atributos_pais(pais, tablero):
	"""Recibe por parametro pais_buscado, que es una cadena y el tablero, que es una instancia
	de la clase Tablero.
		Devuelve el nombre (cadena), los paises limitrofes (lista), el continente (cadena), el
	color (cadena) y la cantidad de ejercitos (entero) del pais, en ese orden, en una lista."""
	return [pais, tablero.tablero[pais].limitrofes, tablero.tablero[pais].continente,\
		tablero.tablero[pais].color, tablero.tablero[pais].ejercitos]


def crear_lista_de_nombre_de_paises(paises_por_tarjeta):
	""" Crea una lista de nombre de paises dado un diccionario que contiene listas
		con los nombres de paises dentro de estas """
	lista_de_nombres_de_paises = []
	
	for tipo_de_pais in paises_por_tarjeta:
		for nombre_de_pais in paises_por_tarjeta[tipo_de_pais]:
			lista_de_nombres_de_paises.append(nombre_de_pais)
	return lista_de_nombres_de_paises

def crear_lista_de_tipos_de_paises(paises_por_tarjeta):
	""" Crea una lista con los tipos de paises que existen dado un diccionrio
		que posee a estos tipos como claves"""
	lista_de_tipos_de_paises = []
	
	for tipo_de_pais in paises_por_tarjeta:
			lista_de_tipos_de_paises.append(tipo_de_pais)
	return lista_de_tipos_de_paises

def pruebas_tablero():
	tablero = Tablero(paises.paises_por_continente, paises.paises_limitrofes)

	print "Prueba del pais con sus paises limitrofes y el continente en el que se encuentra."
	
	prueba = "Prueba con Argentina"
	resultado_esperado = ["Argentina", ['Brasil', 'Chile', 'Peru', 'Uruguay'], "America del Sur"]
	resultado_obtenido = obtener_atributos_pais("Argentina", tablero)[:3]
	ejecutar_prueba(resultado_obtenido == resultado_esperado, prueba)

	prueba = "Prueba con China"
	resultado_esperado = ["China", \
	['Gobi', 'India', 'Iran', 'Japon', 'Kamchatka', 'Malasia', 'Mongolia', 'Siberia'], "Asia"]
	resultado_obtenido = obtener_atributos_pais("China", tablero)[:3]
	ejecutar_prueba(resultado_obtenido == resultado_esperado, prueba)

	prueba = "Prueba con Suecia"
	resultado_esperado = ["Suecia", ['Islandia', 'Rusia'], "Europa"]
	resultado_obtenido = obtener_atributos_pais("Suecia", tablero)[:3]
	ejecutar_prueba(resultado_obtenido == resultado_esperado, prueba)

	print 
	print "Prueba para cambiar color y numero de ejercitos de un pais."

	prueba = "Prueba con Alaska"
	tablero.ocupar_pais("Alaska", NOMBRE_COLORES[COLOR_ROJO])
	resultado_esperado = [NOMBRE_COLORES[COLOR_ROJO], 1]
	resultado_obtenido = obtener_atributos_pais("Alaska", tablero)[3:]
	ejecutar_prueba(resultado_obtenido == resultado_esperado, prueba)

	prueba = "Prueba con Borneo"
	tablero.ocupar_pais("Borneo", NOMBRE_COLORES[COLOR_NEGRO], 17)
	resultado_esperado = [NOMBRE_COLORES[COLOR_NEGRO], 17]
	resultado_obtenido = obtener_atributos_pais("Borneo", tablero)[3:]
	ejecutar_prueba(resultado_obtenido == resultado_esperado, prueba)

	prueba = "Prueba2 con Borneo"
	tablero.ocupar_pais("Borneo", NOMBRE_COLORES[COLOR_ROSA], 3)
	resultado_esperado = [NOMBRE_COLORES[COLOR_ROSA], 20]
	#Borneo ya tenia 17 ejercitos.
	resultado_obtenido = obtener_atributos_pais("Borneo", tablero)[3:]
	ejecutar_prueba(resultado_obtenido == resultado_esperado, prueba)

	print
	print "Prueba para asignar la cantidad correcta de ejercitos a un pais."
	
	prueba = "Prueba con Chile"
	tablero.asignar_ejercitos("Chile", 10)
	resultado_esperado = [10]
	resultado_obtenido = obtener_atributos_pais("Chile", tablero)[4:]
	ejecutar_prueba(resultado_obtenido == resultado_esperado, prueba)

	prueba = "Prueba con Islandia"
	tablero.asignar_ejercitos("Islandia", 7)
	resultado_esperado = [7]
	resultado_obtenido = obtener_atributos_pais("Islandia", tablero)[4:]
	ejecutar_prueba(resultado_obtenido == resultado_esperado, prueba)

	prueba = "Prueba2 con Chile"
	tablero.asignar_ejercitos("Chile", -5)
	resultado_esperado = [5]
	#Chile ya tenia 10 ejercitos.
	resultado_obtenido = obtener_atributos_pais("Chile", tablero)[4:]
	ejecutar_prueba(resultado_obtenido == resultado_esperado, prueba)

	print
	print "Prueba para obtener el color correcto de un pais."

	prueba = "Prueba con Borneo"
	resultado_esperado = NOMBRE_COLORES[COLOR_ROSA]
	#Color asignado en Prueba2 con Borneo.
	resultado_obtenido = tablero.color_pais("Borneo")
	ejecutar_prueba(resultado_obtenido == resultado_esperado, prueba)

	prueba = "Prueba con Alaska"
	resultado_esperado = NOMBRE_COLORES[COLOR_ROJO]
	resultado_obtenido = tablero.color_pais("Alaska")
	#Color asignado en Prueba con Alaska.
	ejecutar_prueba(resultado_obtenido == resultado_esperado, prueba)

	print
	print "Prueba para obtener la cantidad de ejercitos correcta de un pais."

	prueba = "Prueba con Islandia"
	resultado_esperado = 7
	#Ejercitos aisgnados en Prueba con Islandia.
	resultado_obtenido = tablero.ejercitos_pais("Islandia")
	ejecutar_prueba(resultado_obtenido == resultado_esperado, prueba)

	prueba = "Prueba con Chile"
	resultado_esperado = 5
	#Ejercitos aisgnados en Prueba con Chile.
	resultado_obtenido = tablero.ejercitos_pais("Chile")
	ejecutar_prueba(resultado_obtenido == resultado_esperado, prueba)

	print
	print "Prueba para comprobar si dos paises son limitrofes."

	prueba = "Prueba con Gobi y Mongolia"
	resultado_esperado = True
	resultado_obtenido = tablero.es_limitrofe("Gobi", "Mongolia")
	ejecutar_prueba(resultado_obtenido == resultado_esperado, prueba)

	prueba = "Prueba con Argentina y Alemania"
	resultado_esperado = False
	resultado_obtenido = tablero.es_limitrofe("Argentina", "Alemania")
	ejecutar_prueba(resultado_obtenido == resultado_esperado, prueba)

	prueba = "Prueba con Mongolia y Gobi"
	resultado_esperado = True
	resultado_obtenido = tablero.es_limitrofe("Mongolia", "Gobi")
	ejecutar_prueba(resultado_obtenido == resultado_esperado, prueba)

	print
	print "Prueba para obtener la cantidad de paises totales."

	prueba = "Prueba cantidad de paises"
	resultado_esperado = 50
	resultado_obtenido = tablero.cantidad_paises()
	ejecutar_prueba(resultado_obtenido == resultado_esperado, prueba)

	print
	print "Prueba para obtener la cantidad de paises en un continente."

	prueba = "Prueba con Asia"
	resultado_esperado = 15
	resultado_obtenido = tablero.cantidad_paises_continente("Asia")
	ejecutar_prueba(resultado_obtenido == resultado_esperado, prueba)

	prueba = "Prueba con America del Sur"
	resultado_esperado = 6
	resultado_obtenido = tablero.cantidad_paises_continente("America del Sur")
	ejecutar_prueba(resultado_obtenido == resultado_esperado, prueba)

	prueba = "Prueba con Europa"
	resultado_esperado = 9
	resultado_obtenido = tablero.cantidad_paises_continente("Europa")
	ejecutar_prueba(resultado_obtenido == resultado_esperado, prueba)

	print
	print "Prueba para obtener el continente de un pais."

	prueba = "Prueba con Espana"
	resultado_esperado = "Europa"
	resultado_obtenido = tablero.continente_pais("Espana")
	ejecutar_prueba(resultado_obtenido == resultado_esperado, prueba)

	prueba = "Prueba con Java"
	resultado_esperado = "Oceania"
	resultado_obtenido = tablero.continente_pais("Java")
	ejecutar_prueba(resultado_obtenido == resultado_esperado, prueba)

	prueba = "Prueba con Peru"
	resultado_esperado = "America del Sur"
	resultado_obtenido = tablero.continente_pais("Peru")
	ejecutar_prueba(resultado_obtenido == resultado_esperado, prueba)

	print
	print "Prueba para obtener paises con un color."

	prueba = "Prueba con color rosa"
	resultado_esperado = ["Borneo"]
	#Color asignado en Prueba2 con Borneo.
	resultado_obtenido = tablero.paises_color(NOMBRE_COLORES[COLOR_ROSA])
	ejecutar_prueba(resultado_obtenido == resultado_esperado, prueba)

	prueba = "Prueba con color rojo"
	resultado_esperado = ["Alaska"]
	#Color asignado en Prueba con Alaska.
	resultado_obtenido = tablero.paises_color(NOMBRE_COLORES[COLOR_ROJO])
	ejecutar_prueba(resultado_obtenido == resultado_esperado, prueba)


def pruebas_teg():
	teg = TEG()

	print
	print "Prueba para el correcto manejo de tarjetas."

	prueba = "Prueba de jugador con dos tarjetas de paises que posee"
	a = Jugador(NOMBRE_COLORES[COLOR_ROJO], "a")
	teg.tablero.tablero["Argentina"].color = NOMBRE_COLORES[COLOR_ROJO]
	teg.tablero.tablero["Egipto"].color = NOMBRE_COLORES[COLOR_ROJO]
	a.tarjetas.append(Tarjeta("Argentina", TARJETA_COMODIN))
	a.tarjetas.append(Tarjeta("Egipto", TARJETA_GLOBO))

	resultado_esperado = [2, 2]
	teg.manejar_tarjetas(a, 0)
	resultado_obtenido = [obtener_atributos_pais("Argentina", teg.tablero)[4], \
		obtener_atributos_pais("Egipto", teg.tablero)[4]]
	ejecutar_prueba(resultado_obtenido == resultado_esperado, prueba)

	prueba = "Prueba de jugador con 1 pais ganado y con tarjeta de pais que posee"
	#el jugador posee todos los paises porque las tarjetas se reparten aleatoriamente,
	#y se quiere comprobar que se agreguen los ejercitos.
	teg.tablero = Tablero(paises.paises_por_continente, paises.paises_limitrofes)
	b = Jugador(NOMBRE_COLORES[COLOR_ROSA], "b")
	for pais in teg.tablero.tablero:
		teg.tablero.tablero[pais].color = NOMBRE_COLORES[COLOR_ROSA]

	resultado_esperado = [2]
	teg.manejar_tarjetas(b, 1)
	resultado_obtenido = [obtener_atributos_pais(b.tarjetas[0].pais , teg.tablero)[4]]
	ejecutar_prueba(resultado_obtenido == resultado_esperado, prueba)

	prueba = "Prueba de jugador con 1 pais ganado y con tarjeta de pais que no posee"
	#el jugador no posee ningun pais, entonces no se agregaran ejercitos al pais de la tarjeta.
	teg.tablero = Tablero(paises.paises_por_continente, paises.paises_limitrofes)

	resultado_esperado = [0]
	teg.manejar_tarjetas(b, 1)
	resultado_obtenido = [obtener_atributos_pais(b.tarjetas[0].pais , teg.tablero)[4]]
	ejecutar_prueba(resultado_obtenido == resultado_esperado, prueba)

	prueba = "Prueba de jugador recibe tarjeta por ganar un pais"
	resultado_esperado = 2
	#tarjetas agregadas en las dos pruebas anteriores.
	resultado_obtenido = len(b.tarjetas)								
	ejecutar_prueba(resultado_obtenido == resultado_esperado, prueba)

	prueba = "Prueba de jugador con 1 pais ganado, 2 canjes realizados y con tarjeta de pais que posee"
	#el jugador posee todos los paises porque las tarjetas se reparten aleatoriamente,
	#y se quiere comprobar que se agreguen los ejercitos.
	teg.tablero = Tablero(paises.paises_por_continente, paises.paises_limitrofes)
	c = Jugador(NOMBRE_COLORES[COLOR_NEGRO], "c")
	for pais in teg.tablero.tablero:
		teg.tablero.tablero[pais].color = NOMBRE_COLORES[COLOR_NEGRO]
	teg.canjes[c] = 2

	resultado_esperado = [2]
	teg.manejar_tarjetas(c, 1)
	resultado_obtenido = [obtener_atributos_pais(c.tarjetas[1].pais, teg.tablero)[4]]
	ejecutar_prueba(resultado_obtenido == resultado_esperado, prueba)

	prueba = "Prueba de jugador con 2 paises ganados, 4 canjes realizados y con tarjeta de pais que posee"
	#el jugador posee todos los paises porque las tarjetas se reparten aleatoriamente,
	#y se quiere comprobar que se agreguen los ejercitos.
	teg.tablero = Tablero(paises.paises_por_continente, paises.paises_limitrofes)
	d = Jugador(NOMBRE_COLORES[COLOR_AZUL], "d")
	for pais in teg.tablero.tablero:
		teg.tablero.tablero[pais].color = NOMBRE_COLORES[COLOR_AZUL]
	teg.canjes[d] = 4

	resultado_esperado = [2]
	teg.manejar_tarjetas(d, 2)
	resultado_obtenido = [obtener_atributos_pais(d.tarjetas[1].pais, teg.tablero)[4]]
	ejecutar_prueba(resultado_obtenido == resultado_esperado, prueba)

	prueba = "Prueba de jugador recibe tarjetas por 2 paises ganados, 4 canjes realizados y con tarjeta de pais que posee"
	resultado_esperado = 2
	#tarjetas agregadas en la prueba anterior.
	resultado_obtenido = len(d.tarjetas)
	ejecutar_prueba(resultado_obtenido == resultado_esperado, prueba)

	print
	print "Prueba para obtener la cantidad de tarjetas iguales y distintas de un jugador"

	prueba = "Prueba con 2 tarjetas iguales y 1 distinta"
	e = Jugador(NOMBRE_COLORES[COLOR_AMARILLO], "e")
	e.tarjetas = [Tarjeta("Borneo", TARJETA_GALEON), Tarjeta("Brasil", TARJETA_GALEON),\
		Tarjeta("Java", TARJETA_CANON)]
	resultado_esperado = ([2,[TARJETA_GALEON]], [2,[TARJETA_GALEON, TARJETA_CANON]])
	resultado_obtenido = teg._obtener_cant_tipo(e)
	ejecutar_prueba(resultado_obtenido == resultado_esperado, prueba)

	prueba = "Prueba con 4 tarjetas iguales y 3 distintas"
	f = Jugador(NOMBRE_COLORES[COLOR_AMARILLO], "f")
	f.tarjetas = [Tarjeta("Borneo", TARJETA_GALEON), Tarjeta("Brasil", TARJETA_GALEON),\
		Tarjeta("Java", TARJETA_CANON), Tarjeta("Argentina", TARJETA_COMODIN), Tarjeta("Peru", TARJETA_GALEON)]
	resultado_esperado = ([4,[TARJETA_COMODIN, TARJETA_GALEON]], [3,[TARJETA_COMODIN, TARJETA_GALEON, TARJETA_CANON]])
	resultado_obtenido = teg._obtener_cant_tipo(f)
	ejecutar_prueba(resultado_obtenido == resultado_esperado, prueba)

	prueba = "Prueba con 2 tarjetas iguales y 3 distintas"
	g = Jugador(NOMBRE_COLORES[COLOR_AMARILLO], "g")
	g.tarjetas = [Tarjeta("Borneo", TARJETA_GALEON), Tarjeta("Java", TARJETA_CANON),\
		Tarjeta("Argentina", TARJETA_COMODIN)]
	resultado_esperado = ([1,[TARJETA_COMODIN]], [3,[TARJETA_COMODIN, TARJETA_GALEON, TARJETA_CANON]])
	#se toman en cuenta las 3 distintas para realizar el canje
	resultado_obtenido = teg._obtener_cant_tipo(g)
	ejecutar_prueba(resultado_obtenido == resultado_esperado, prueba)

	prueba = "Prueba con 3 tarjetas iguales y 2 distintas"
	h = Jugador(NOMBRE_COLORES[COLOR_AMARILLO], "h")
	h.tarjetas = [Tarjeta("Borneo", TARJETA_GALEON), Tarjeta("Brasil", TARJETA_GALEON),\
		Tarjeta("Argentina", TARJETA_COMODIN)]
	resultado_esperado = ([3,[TARJETA_COMODIN, TARJETA_GALEON]], [2,[TARJETA_COMODIN, TARJETA_GALEON]])
	resultado_obtenido = teg._obtener_cant_tipo(h)
	ejecutar_prueba(resultado_obtenido == resultado_esperado, prueba)

	print
	print "Prueba para comprobar si un jugador puede canjear tarjetas o no"

	prueba = "Prueba con jugador que no puede realizar canje"
	resultado_esperado = False
	#tarjetas asignadas en la anterior prueba
	resultado_obtenido = teg._realizar_canje(e)
	ejecutar_prueba(resultado_obtenido == resultado_esperado, prueba)

	prueba = "Prueba con jugador que puede realizar canje"
	resultado_esperado = True
	#tarjetas asignadas en la anterior prueba
	resultado_obtenido = teg._realizar_canje(f)
	ejecutar_prueba(resultado_obtenido == resultado_esperado, prueba)

	prueba = "Prueba1 con jugador que realiza canje, y se le sacan las tarjetas para ser devueltas"
	resultado_esperado = []
	#tarjetas asignadas en la anterior prueba
	teg._realizar_canje(h)
	resultado_obtenido = h.tarjetas
	ejecutar_prueba(resultado_obtenido == resultado_esperado, prueba)

	prueba = "Prueba2 con jugador que realiza canje, y se le sacan las tarjetas para ser devueltas"
	resultado_esperado = []
	teg._realizar_canje(g)
	resultado_obtenido = g.tarjetas
	ejecutar_prueba(resultado_obtenido == resultado_esperado, prueba)

	print
	print "Prueba para comprobar si un jugador posee un continente completo"

	prueba = "Prueba con el continente America del Sur ocupado completamente por un jugador"
	resultado_esperado = True
	resultado_obtenido = teg._es_continente_completo("America del Sur", paises.paises_por_continente["America del Sur"])
	ejecutar_prueba(resultado_obtenido == resultado_esperado, prueba)

	prueba = "Prueba con jugador que no posee un continente completo"
	resultado_esperado = False
	resultado_obtenido = teg._es_continente_completo("Oceania", ['Australia', 'Borneo', 'Java', "Peru"])
	ejecutar_prueba(resultado_obtenido == resultado_esperado, prueba)

	print
	print "Prueba para el correcto agregado de ejercitos."
	teg.jugadores.append(f)
	f.color = COLOR_AMARILLO

	print "Prueba con jugador que realizo un canje.  Se debe colocar primero dos ejercitos en Brasil, luego dos en Peru y luego tres en brasil por poseer dos paises"
	teg.canjes = {}
	teg.tablero = Tablero(paises.paises_por_continente, paises.paises_limitrofes)
	teg.tablero.tablero["Brasil"].color = COLOR_AMARILLO
	teg.tablero.tablero["Peru"].color = COLOR_AMARILLO
	f.tarjetas = [Tarjeta("Borneo", TARJETA_GALEON), Tarjeta("Brasil", TARJETA_GALEON),\
		Tarjeta("Java", TARJETA_CANON), Tarjeta("Argentina", TARJETA_COMODIN), Tarjeta("Peru", TARJETA_GALEON)]

	resultado_esperado = [5, 2]
	teg.agregar_ejercitos(0)
	resultado_obtenido = [obtener_atributos_pais("Brasil", teg.tablero)[4],\
		obtener_atributos_pais("Peru", teg.tablero)[4]]
	ejecutar_prueba(resultado_obtenido == resultado_esperado)

	print "Prueba con jugador que realizo dos canjes. Se deben colocar primero cuatro ejercitos en Brasil, luego tres en Peru y luego tres en brasil por poseer dos paises"
	teg.tablero = Tablero(paises.paises_por_continente, paises.paises_limitrofes)
	teg.tablero.tablero["Brasil"].color = COLOR_AMARILLO
	teg.tablero.tablero["Peru"].color = COLOR_AMARILLO
	f.tarjetas = [Tarjeta("Borneo", TARJETA_GALEON), Tarjeta("Brasil", TARJETA_GALEON),\
		Tarjeta("Java", TARJETA_CANON), Tarjeta("Argentina", TARJETA_COMODIN), Tarjeta("Peru", TARJETA_GALEON)]

	resultado_esperado = [7, 3]
	teg.agregar_ejercitos(0)
	resultado_obtenido = [obtener_atributos_pais("Brasil", teg.tablero)[4],\
		obtener_atributos_pais("Peru", teg.tablero)[4]]
	ejecutar_prueba(resultado_obtenido == resultado_esperado)

	print "Prueba con jugador que realizo tres canjes. Se deben colocar primero cinco ejercitos en Brasil, luego cinco en Peru y luego tres en brasil por poseer dos paises"
	teg.tablero = Tablero(paises.paises_por_continente, paises.paises_limitrofes)
	teg.tablero.tablero["Brasil"].color = COLOR_AMARILLO
	teg.tablero.tablero["Peru"].color = COLOR_AMARILLO
	f.tarjetas = [Tarjeta("Borneo", TARJETA_GALEON), Tarjeta("Brasil", TARJETA_GALEON),\
		Tarjeta("Java", TARJETA_CANON), Tarjeta("Argentina", TARJETA_COMODIN), Tarjeta("Peru", TARJETA_GALEON)]

	resultado_esperado = [8, 5]
	teg.agregar_ejercitos(0)
	resultado_obtenido = [obtener_atributos_pais("Brasil", teg.tablero)[4],\
		obtener_atributos_pais("Peru", teg.tablero)[4]]
	ejecutar_prueba(resultado_obtenido == resultado_esperado)

	print "Prueba con jugador que no posee canjes y posee ocho paises. Se deben colocar primero 3 ejercitos en Espana y luego 1 en Francia"
	teg.canjes = {}
	f.tarjetas = []
	teg.tablero = Tablero(paises.paises_por_continente, paises.paises_limitrofes)
	for pais in ['Alemania', 'Espana', 'Francia', 'Gran Bretana', 'Islandia', 'Italia', 'Polonia', 'Rusia']:
		teg.tablero.tablero[pais].color = COLOR_AMARILLO
		teg.tablero.tablero[pais].ejercitos = 1

	resultado_esperado = [4, 2]
	teg.agregar_ejercitos(0)
	resultado_obtenido = [obtener_atributos_pais("Espana", teg.tablero)[4],\
		obtener_atributos_pais("Francia", teg.tablero)[4]]
	ejecutar_prueba(resultado_obtenido == resultado_esperado)

	print "Prueba con jugador que no posee canjes y posee 2 paises. Se deben colocar primero 2 ejercitos en Polonia y luego 1 en Rusia"
	teg.canjes = {}
	f.tarjetas = []
	teg.tablero = Tablero(paises.paises_por_continente, paises.paises_limitrofes)
	for pais in ['Polonia', 'Rusia']:
		teg.tablero.tablero[pais].color = COLOR_AMARILLO
		teg.tablero.tablero[pais].ejercitos = 1

	resultado_esperado = [3, 2]
	teg.agregar_ejercitos(0)
	resultado_obtenido = [obtener_atributos_pais("Polonia", teg.tablero)[4],\
		obtener_atributos_pais("Rusia", teg.tablero)[4]]
	ejecutar_prueba(resultado_obtenido == resultado_esperado)

	print "Prueba con jugador que no posee canjes y America del Sur completo. Se colocan primero tres ejercitos en Argentina y luego tres en Brasil"
	teg.canjes = {}
	f.tarjetas = []
	teg.tablero = Tablero(paises.paises_por_continente, paises.paises_limitrofes)
	for pais in paises.paises_por_continente["America del Sur"]:
		teg.tablero.tablero[pais].color = COLOR_AMARILLO
		teg.tablero.tablero[pais].ejercitos = 1

	resultado_esperado = [4, 4]
	teg.agregar_ejercitos(0)
	resultado_obtenido = [obtener_atributos_pais("Argentina", teg.tablero)[4],\
		obtener_atributos_pais("Brasil", teg.tablero)[4]]
	ejecutar_prueba(resultado_obtenido == resultado_esperado)

	print
	print "Prueba si un jugador es el ganador del juego"

	prueba = "Prueba con un jugador que gano el juego"
	teg.tablero = Tablero(paises.paises_por_continente, paises.paises_limitrofes)
	for pais in teg.tablero.tablero:
		teg.tablero.tablero[pais].color = COLOR_AMARILLO
		teg.tablero.tablero[pais].ejercitos = 1
	resultado_esperado = True
	resultado_obtenido = teg.jugador_es_ganador(f)
	ejecutar_prueba(resultado_obtenido == resultado_esperado, prueba)

	prueba = "Prueba con un jugador que no gano el juego"
	teg.tablero = Tablero(paises.paises_por_continente, paises.paises_limitrofes)
	resultado_esperado = False
	resultado_obtenido = teg.jugador_es_ganador(f)
	ejecutar_prueba(resultado_obtenido == resultado_esperado, prueba)

	print
	print "Prueba si un jugador esta vivo"

	prueba = "Prueba con un jugador que perdio"
	resultado_esperado = False
	resultado_obtenido = teg.jugador_esta_vivo(f)
	ejecutar_prueba(resultado_obtenido == resultado_esperado, prueba)


def pruebas_jugador():
	teg = TEG()
	jugador = Jugador(COLOR_ROJO, "jugador")

	print
	print "Prueba para el correcto agregado de ejercitos"

	for pais in teg.tablero.tablero:
		teg.tablero.tablero[pais].color = COLOR_ROJO
		teg.tablero.tablero[pais].ejercitos = 1

	teg.tablero.actualizar_interfaz()

	print "Prueba con jugador que agrega ejercitos en cualquier continente. Se deben colocar primero dos ejercitos en Argentina, luego uno en Alaska y tres en Espana."
	resultado_esperado = {"Argentina":2, "Alaska":1, "Espana":3}
	resultado_obtenido = jugador.agregar_ejercitos(teg.tablero, {"":6})
	ejecutar_prueba(resultado_obtenido == resultado_esperado)

	print "Prueba con jugador que puede agregar solo ejercitos en America del Sur. Se pueden colocar ejercitos en cualquier pais de America del Sur."
	teg.tablero.actualizar_interfaz()
	paises_esperados = paises.paises_por_continente["America del Sur"]
	resultado_esperado = True
	resultado = jugador.agregar_ejercitos(teg.tablero, {"America del Sur":3})
	for pais in resultado:
		if pais not in paises_esperados:
			resultado_obtenido = False
	resultado_obtenido = True
	ejecutar_prueba(resultado_obtenido == resultado_esperado)

	prueba = "Prueba en base a la ultima prueba. El tablero no se modifica porque el jugador no lo tiene permitido"
	resultado_esperado = True
	for pais in resultado:
		if obtener_atributos_pais(pais, teg.tablero)[4] != 1:
			resultado_obtenido = False
	resultado_obtenido = True
	ejecutar_prueba(resultado_obtenido == resultado_esperado, prueba)

	print
	print "Prueba para el correcto reagrupamiento de ejercitos"
	for pais in teg.tablero.tablero:
		teg.tablero.tablero[pais].ejercitos += 1
	teg.tablero.actualizar_interfaz()

	print "Prueba reagupando un ejercito de Argentina a Peru, y de Peru a Colombia"
	resultado_esperado = [("Argentina", "Peru", 1), ("Peru", "Colombia", 1)]
	resultado_obtenido = jugador.reagrupar(teg.tablero)
	ejecutar_prueba(resultado_obtenido == resultado_esperado)

	prueba = "Prueba en base a la ultima prueba. El tablero no se modifica porque el jugador no lo tiene permitido"
	resultado_esperado = [2, 2, 2]
	resultado_obtenido = [obtener_atributos_pais("Argentina", teg.tablero)[4], obtener_atributos_pais("Peru", teg.tablero)[4],\
		obtener_atributos_pais("Colombia", teg.tablero)[4]]
	ejecutar_prueba(resultado_obtenido == resultado_esperado, prueba)


def pruebas_mazo():
	print
	print "Pruebas de funcionamiento de la clase Mazo"
	mazo_de_prueba = Mazo(paises.paises_por_tarjeta)
	
	prueba = "Prueba de cantidad de cartas en mazo al sacar 1 sin devolver"
	resultado_esperado = 49
	auxiliar = mazo_de_prueba.sacar_tarjeta()
	resultado_obtenido = mazo_de_prueba.cantidad_tarjetas()
	ejecutar_prueba( resultado_esperado == resultado_obtenido, prueba)
	
	prueba = "Prueba de cantidad de cartas en mazo al devolver las tarjetas"
	resultado_esperado = 50
	mazo_de_prueba.devolver_tarjeta(auxiliar)
	resultado_obtenido = mazo_de_prueba.cantidad_tarjetas()
	ejecutar_prueba( resultado_esperado == resultado_obtenido, prueba)
	
	prueba = "Prueba del nombre del pais sacado, sea correcto"
	resultado_esperado = crear_lista_de_nombre_de_paises(paises.paises_por_tarjeta)
	auxiliar = mazo_de_prueba.sacar_tarjeta()
	resultado_obtenido = auxiliar.pais
	mazo_de_prueba.devolver_tarjeta(auxiliar)
	ejecutar_prueba(resultado_obtenido in resultado_esperado, prueba)
	
	prueba = "Prueba que el tipo de carta del pais exista"
	resultado_esperado = crear_lista_de_tipos_de_paises(paises.paises_por_tarjeta)
	auxiliar = mazo_de_prueba.sacar_tarjeta()
	resultado_obtenido = auxiliar.tipo
	mazo_de_prueba.devolver_tarjeta(auxiliar)
	ejecutar_prueba(resultado_obtenido in resultado_esperado, prueba)
	
	
def pruebas_dados():
	print
	print "Pruebas de la clase Dados"
	
	dado_de_prueba = Dados()
		
	prueba = "Prueba sobre la cantidad de dados del atacante"
	dado_de_prueba.lanzar_dados(2,3)
	resultado_esperado = 1
	resultado_obtenido = len(dado_de_prueba.dados_atacante)
	ejecutar_prueba( resultado_esperado == resultado_obtenido, prueba)
	
	prueba = "Prueba sobre la cantidad de dados del jugador que defiende"
	dado_de_prueba.lanzar_dados(2,5)
	resultado_esperado = 3
	resultado_obtenido = len(dado_de_prueba.dados_atacado)
	ejecutar_prueba( resultado_esperado == resultado_obtenido, prueba)
	
	prueba = "Prueba sobre el rango de ejercitos perdidos del atacante"
	dado_de_prueba.lanzar_dados(5,2)
	resultado_esperado = [0, 1, 2, 3]
	resultado_obtenido = dado_de_prueba.ejercitos_perdidos_atacante()
	
	ejecutar_prueba( resultado_obtenido in resultado_esperado , prueba)
	
	prueba = "Prueba sobre el rango de ejercitos perdidos del atacado"
	dado_de_prueba.lanzar_dados(5,2)
	resultado_esperado = [0, 1, 2, 3]
	resultado_obtenido = dado_de_prueba.ejercitos_perdidos_atacado()
	
	ejecutar_prueba( resultado_obtenido in resultado_esperado , prueba)


def ejecutar_todas_las_pruebas():
	"""Ejecuta todas las pruebas que permiten verificar el correcto	funcionamiento
	de las clases y metodos desarrollados."""
	pruebas_tablero()
	pruebas_teg()
	pruebas_dados()
	pruebas_mazo()
	pruebas_jugador()


ejecutar_todas_las_pruebas()